/************************************************************************************
Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.

Licensed under the Oculus Master SDK License Version 1.0 (the "License"); you may not use
the Utilities SDK except in compliance with the License, which is provided at the time of installation
or download, or which otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at
https://developer.oculus.com/licenses/oculusmastersdk-1.0/

Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
ANY KIND, either express or implied. See the License for the specific language governing
permissions and limitations under the License.
************************************************************************************/

using UnityEngine;
using System;
using System.Collections;
using System.Runtime.InteropServices;

/// <summary>
/// Add OVROverlay script to an object with an optional mesh primitive
/// rendered as a TimeWarp overlay instead by drawing it into the eye buffer.
/// This will take full advantage of the display resolution and avoid double
/// resampling of the texture.
///
/// We support 3 types of Overlay shapes right now
///		1. Quad : This is most common overlay type , you render a quad in Timewarp space.
///		2. Cylinder: [Mobile Only][Experimental], Display overlay as partial surface of a cylinder
///			* The cylinder's center will be your game object's center
///			* We encoded the cylinder's parameters in transform.scale,
///				**[scale.z] is the radius of the cylinder
///				**[scale.y] is the height of the cylinder
///				**[scale.x] is the length of the arc of cylinder
///		* Limitations
///				**Only the half of the cylinder can be displayed, which means the arc angle has to be smaller than 180 degree,  [scale.x] / [scale.z] <= PI
///				**Your camera has to be inside of the inscribed sphere of the cylinder, the overlay will be faded out automatically when the camera is close to the inscribed sphere's surface.
///				**Translation only works correctly with vrDriver 1.04 or above
///		3. Cubemap: Display overlay as a cube map
///		4. OffcenterCubemap: [Mobile Only] Display overlay as a cube map with a texture coordinate offset
///			* The actually sampling will looks like [color = texture(cubeLayerSampler, normalize(direction) + offset)] instead of [color = texture( cubeLayerSampler, direction )]
///			* The extra center offset can be feed from transform.position
///			* Note: if transform.position's magnitude is greater than 1, which will cause some cube map pixel always invisible
///					Which is usually not what people wanted, we don't kill the ability for developer to do so here, but will warn out.
///		5. Equirect: Display overlay as a 360-degree equirectangular skybox.
/// </summary>
[ExecuteInEditMode]
public class OVROverlay : MonoBehaviour
{
#region Interface

	/// <summary>
	/// Determines the on-screen appearance of a layer.
	/// </summary>
	public enum OverlayShape
	{
		Quad = OVRPlugin.OverlayShape.Quad,
		Cylinder = OVRPlugin.OverlayShape.Cylinder,
		Cubemap = OVRPlugin.OverlayShape.Cubemap,
		OffcenterCubemap = OVRPlugin.OverlayShape.OffcenterCubemap,
		Equirect = OVRPlugin.OverlayShape.Equirect,
	}

	/// <summary>
	/// Whether the layer appears behind or infront of other content in the scene.
	/// </summary>
	public enum OverlayType
	{
		None,
		Underlay,
		Overlay,
	};

	/// <summary>
	/// Specify overlay's type
	/// </summary>
	[Tooltip("Specify overlay's type")]
	public OverlayType currentOverlayType = OverlayType.Overlay;

	/// <summary>
	/// If true, the texture's content is copied to the compositor each frame.
	/// </summary>
	[Tooltip("If true, the texture's content is copied to the compositor each frame.")]
	public bool isDynamic = false;

	/// <summary>
	/// If true, the layer would be used to present protected content (e.g. HDCP). The flag is effective only on PC.
	/// </summary>
	[Tooltip("If true, the layer would be used to present protected content (e.g. HDCP). The flag is effective only on PC.")]
	public bool isProtectedContent = false;

	//Source and dest rects
	public Rect srcRectLeft = new Rect();
	public Rect srcRectRight = new Rect();
	public Rect destRectLeft = new Rect();
	public Rect destRectRight = new Rect();

	// Used to support legacy behavior where the top left was considered the origin
	public bool invertTextureRects = false;

	private OVRPlugin.TextureRectMatrixf textureRectMatrix = OVRPlugin.TextureRectMatrixf.zero;

	public bool overrideTextureRectMatrix = false;

	public bool overridePerLayerColorScaleAndOffset = false;

	public	Vector4 colorScale = Vector4.one;

	public Vector4 colorOffset = Vector4.zero;

	//Warning: Developers should only use this supersample setting if they absolutely have the budget and need for it. It is extremely expensive, and will not be relevant for most developers.
	public bool useExpensiveSuperSample = false;

	//Property that can hide overlays when required. Should be false when present, true when hidden.
	public bool hidden = false;

	/// <summary>
	/// If true, the layer will be created as an external surface. externalSurfaceObject contains the Surface object. It's effective only on Android.
	/// </summary>
	[Tooltip("If true, the layer will be created as an external surface. externalSurfaceObject contains the Surface object. It's effective only on Android.")]
	public bool isExternalSurface = false;

	/// <summary>
	/// The width which will be used to create the external surface. It's effective only on Android.
	/// </summary>
	[Tooltip("The width which will be used to create the external surface. It's effective only on Android.")]
	public int externalSurfaceWidth = 0;

	/// <summary>
	/// The height which will be used to create the external surface. It's effective only on Android.
	/// </summary>
	[Tooltip("The height which will be used to create the external surface. It's effective only on Android.")]
	public int externalSurfaceHeight = 0;

	/// <summary>
	/// The compositionDepth defines the order of the OVROverlays in composition. The overlay/underlay with smaller compositionDepth would be composited in the front of the overlay/underlay with larger compositionDepth.
	/// </summary>
	[Tooltip("The compositionDepth defines the order of the OVROverlays in composition. The overlay/underlay with smaller compositionDepth would be composited in the front of the overlay/underlay with larger compositionDepth.")]
	public int compositionDepth = 0;

	/// <summary>
	/// The noDepthBufferTesting will stop layer's depth buffer compositing even if the engine has "Depth buffer sharing" enabled on Rift.
	/// </summary>
	[Tooltip("The noDepthBufferTesting will stop layer's depth buffer compositing even if the engine has \"Shared Depth Buffer\" enabled")]
	public bool noDepthBufferTesting = false;

	//Format corresponding to the source texture for this layer. sRGB by default, but can be modified if necessary
	public OVRPlugin.EyeTextureFormat layerTextureFormat = OVRPlugin.EyeTextureFormat.R8G8B8A8_sRGB;

	/// <summary>
	/// Specify overlay's shape
	/// </summary>
	[Tooltip("Specify overlay's shape")]
	public OverlayShape currentOverlayShape = OverlayShape.Quad;
	private OverlayShape prevOverlayShape = OverlayShape.Quad;

	/// <summary>
	/// The left- and right-eye Textures to show in the layer.
	/// \note If you need to change the texture on a per-frame basis, please use OverrideOverlayTextureInfo(..) to avoid caching issues.
	/// </summary>
	[Tooltip("The left- and right-eye Textures to show in the layer.")]
	public Texture[] textures = new Texture[] { null, null };

	[Tooltip("When checked, the texture is treated as if the alpha was already premultiplied")]
	public bool isAlphaPremultiplied = false;

	/// <summary>
	/// Preview the overlay in the editor using a mesh renderer.
	/// </summary>
	public bool previewInEditor {
		get {
			return _previewInEditor;
		}
		set {
			if (_previewInEditor != value) {
				_previewInEditor = value;
				SetupEditorPreview();
			}
		}
	}

	[SerializeField]
	private bool _previewInEditor = false;
	
#if UNITY_EDITOR
	private GameObject previewObject;
#endif

	protected IntPtr[] texturePtrs = new IntPtr[] { IntPtr.Zero, IntPtr.Zero };

	/// <summary>
	/// The Surface object (Android only).
	/// </summary>
	public System.IntPtr externalSurfaceObject;

	public delegate void ExternalSurfaceObjectCreated();
	/// <summary>
	/// Will be triggered after externalSurfaceTextueObject get created.
	/// </summary>
	public ExternalSurfaceObjectCreated externalSurfaceObjectCreated;

	/// <summary>
	/// Use this function to set texture and texNativePtr when app is running
	/// GetNativeTexturePtr is a slow behavior, the value should be pre-cached
	/// </summary>
	public void OverrideOverlayTextureInfo(Texture srcTexture, IntPtr nativePtr, UnityEngine.XR.XRNode node)
	{
		int index = (node == UnityEngine.XR.XRNode.RightEye) ? 1 : 0;

		if (textures.Length <= index)
			return;

		textures[index] = srcTexture;
		texturePtrs[index] = nativePtr;

		isOverridePending = true;
	}

	protected bool isOverridePending;

	internal const int maxInstances = 15;
	public static OVROverlay[] instances = new OVROverlay[maxInstances];

#endregion

	private static Material tex2DMaterial;
	private static Material cubeMaterial;

	private OVRPlugin.LayerLayout layout {
		get {
#if UNITY_ANDROID && !UNITY_EDITOR
			if (textures.Length == 2 && textures[1] != null && textures[1] != textures[0])
				return OVRPlugin.LayerLayout.Stereo;
#endif
			return OVRPlugin.LayerLayout.Mono;
		}
	}

	private struct LayerTexture {
		public Texture appTexture;
		public IntPtr appTexturePtr;
		public Texture[] swapChain;
		public IntPtr[] swapChainPtr;
	};
	private LayerTexture[] layerTextures;

	private OVRPlugin.LayerDesc layerDesc;
	private int stageCount = -1;

	private int layerIndex = -1; // Controls the composition order based on wake-up time.

	private int layerId = 0; // The layer's internal handle in the compositor.
	private GCHandle layerIdHandle;
	private IntPtr layerIdPtr = IntPtr.Zero;

	private int frameIndex = 0;
	private int prevFrameIndex = -1;

	private Renderer rend;

	private int texturesPerStage { get { return (layout == OVRPlugin.LayerLayout.Stereo) ? 2 : 1; } }

	private bool CreateLayer(int mipLevels, int sampleCount, OVRPlugin.EyeTextureFormat etFormat, int flags, OVRPlugin.Sizei size, OVRPlugin.OverlayShape shape)
	{
		if (!layerIdHandle.IsAllocated || layerIdPtr == IntPtr.Zero)
		{
			layerIdHandle = GCHandle.Alloc(layerId, GCHandleType.Pinned);
			layerIdPtr = layerIdHandle.AddrOfPinnedObject();
		}

		if (layerIndex == -1)
		{
			for (int i = 0; i < maxInstances; ++i)
			{
				if (instances[i] == null || instances[i] == this)
				{
					layerIndex = i;
					instances[i] = this;
					break;
				}
			}
		}

		bool needsSetup = (
			isOverridePending ||
			layerDesc.MipLevels != mipLevels ||
			layerDesc.SampleCount != sampleCount ||
			layerDesc.Format != etFormat ||
			layerDesc.Layout != layout ||
			layerDesc.LayerFlags != flags ||
			!layerDesc.TextureSize.Equals(size) ||
			layerDesc.Shape != shape);

		if (!needsSetup)
			return false;

		OVRPlugin.LayerDesc desc = OVRPlugin.CalculateLayerDesc(shape, layout, size, mipLevels, sampleCount, etFormat, flags);
		OVRPlugin.EnqueueSetupLayer(desc, compositionDepth, layerIdPtr);
		layerId = (int)layerIdHandle.Target;

		if (layerId > 0)
		{
			layerDesc = desc;
			if (isExternalSurface)
			{
				stageCount = 1;
			}
			else
			{
				stageCount = OVRPlugin.GetLayerTextureStageCount(layerId);
			}
		}

		isOverridePending = false;

		return true;
	}

	private bool CreateLayerTextures(bool useMipmaps, OVRPlugin.Sizei size, bool isHdr)
	{
		if (isExternalSurface)
		{
			if (externalSurfaceObject == System.IntPtr.Zero)
			{
				externalSurfaceObject = OVRPlugin.GetLayerAndroidSurfaceObject(layerId);
				if (externalSurfaceObject != System.IntPtr.Zero)
				{
					Debug.LogFormat("GetLayerAndroidSurfaceObject returns {0}", externalSurfaceObject);
					if (externalSurfaceObjectCreated != null)
					{
						externalSurfaceObjectCreated();
					}
				}
			}
			return false;
		}

		bool needsCopy = false;

		if (stageCount <= 0)
			return false;

		// For newer SDKs, blit directly to the surface that will be used in compositing.

		if (layerTextures == null)
			layerTextures = new LayerTexture[texturesPerStage];

		for (int eyeId = 0; eyeId < texturesPerStage; ++eyeId)
		{
			if (layerTextures[eyeId].swapChain == null)
				layerTextures[eyeId].swapChain = new Texture[stageCount];

			if (layerTextures[eyeId].swapChainPtr == null)
				layerTextures[eyeId].swapChainPtr = new IntPtr[stageCount];

			for (int stage = 0; stage < stageCount; ++stage)
			{
				Texture sc = layerTextures[eyeId].swapChain[stage];
				IntPtr scPtr = layerTextures[eyeId].swapChainPtr[stage];

				if (sc != null && scPtr != IntPtr.Zero && size.w == sc.width && size.h == sc.height)
					continue;

				if (scPtr == IntPtr.Zero)
					scPtr = OVRPlugin.GetLayerTexture(layerId, stage, (OVRPlugin.Eye)eyeId);

				if (scPtr == IntPtr.Zero)
					continue;

				var txFormat = (isHdr) ? TextureFormat.RGBAHalf : TextureFormat.RGBA32;

				if (currentOverlayShape != OverlayShape.Cubemap && currentOverlayShape != OverlayShape.OffcenterCubemap)
					sc = Texture2D.CreateExternalTexture(size.w, size.h, txFormat, useMipmaps, true, scPtr);
				else
					sc = Cubemap.CreateExternalTexture(size.w, txFormat, useMipmaps, scPtr);

				layerTextures[eyeId].swapChain[stage] = sc;
				layerTextures[eyeId].swapChainPtr[stage] = scPtr;

				needsCopy = true;
			}
		}

		return needsCopy;
	}

	private void DestroyLayerTextures()
	{
		if (isExternalSurface)
		{
			return;
		}

		for (int eyeId = 0; layerTextures != null && eyeId < texturesPerStage; ++eyeId)
		{
			if (layerTextures[eyeId].swapChain != null)
			{
				for (int stage = 0; stage < stageCount; ++stage)
					DestroyImmediate(layerTextures[eyeId].swapChain[stage]);
			}
		}

		layerTextures = null;
	}

	private void DestroyLayer()
	{
		if (layerIndex != -1)
		{
			// Turn off the overlay if it was on.
			OVRPlugin.EnqueueSubmitLayer(true, false, false, IntPtr.Zero, IntPtr.Zero, -1, 0, OVRPose.identity.ToPosef_Legacy(), Vector3.one.ToVector3f(), layerIndex, (OVRPlugin.OverlayShape)prevOverlayShape);
			instances[layerIndex] = null;
			layerIndex = -1;
		}

		if (layerIdPtr != IntPtr.Zero)
		{
			OVRPlugin.EnqueueDestroyLayer(layerIdPtr);
			layerIdPtr = IntPtr.Zero;
			layerIdHandle.Free();
			layerId = 0;
		}

		layerDesc = new OVRPlugin.LayerDesc();

		frameIndex = 0;
		prevFrameIndex = -1;
	}

	/// <summary>
	/// Sets the source and dest rects for both eyes. Source explains what portion of the source texture is used, and
	/// dest is what portion of the destination texture is rendered into.
	/// </summary>
	public void SetSrcDestRects(Rect srcLeft, Rect srcRight, Rect destLeft, Rect destRight)
	{
		srcRectLeft = srcLeft;
		srcRectRight = srcRight;
		destRectLeft = destLeft;
		destRectRight = destRight;
	}

	public void UpdateTextureRectMatrix()
	{
		// External surfaces are encoded with reversed UV's, so our texture rects are also inverted
		Rect srcRectLeftConverted = new Rect(srcRectLeft.x, isExternalSurface ^ invertTextureRects ? 1 - srcRectLeft.y - srcRectLeft.height : srcRectLeft.y, srcRectLeft.width, srcRectLeft.height);
		Rect srcRectRightConverted = new Rect(srcRectRight.x, isExternalSurface ^ invertTextureRects ? 1 - srcRectRight.y - srcRectRight.height : srcRectRight.y, srcRectRight.width, srcRectRight.height);
		Rect destRectLeftConverted = new Rect(destRectLeft.x, isExternalSurface ^ invertTextureRects ? 1 - destRectLeft.y - destRectLeft.height : destRectLeft.y, destRectLeft.width, destRectLeft.height);
		Rect destRectRightConverted = new Rect(destRectRight.x, isExternalSurface ^ invertTextureRects ? 1 - destRectRight.y - destRectRight.height : destRectRight.y, destRectRight.width, destRectRight.height);
		textureRectMatrix.leftRect = srcRectLeftConverted;
		textureRectMatrix.rightRect = srcRectRightConverted;

		float leftWidthFactor = srcRectLeft.width / destRectLeft.width;
		float leftHeightFactor = srcRectLeft.height / destRectLeft.height;
		textureRectMatrix.leftScaleBias = new Vector4(leftWidthFactor, leftHeightFactor, srcRectLeftConverted.x - destRectLeftConverted.x * leftWidthFactor, srcRectLeftConverted.y - destRectLeftConverted.y * leftHeightFactor);
		float rightWidthFactor = srcRectRight.width / destRectRight.width;
		float rightHeightFactor = srcRectRight.height / destRectRight.height;
		textureRectMatrix.rightScaleBias = new Vector4(rightWidthFactor, rightHeightFactor, srcRectRightConverted.x - destRectRightConverted.x * rightWidthFactor, srcRectRightConverted.y - destRectRightConverted.y * rightHeightFactor);
	}

	public void SetPerLayerColorScaleAndOffset(Vector4 scale, Vector4 offset)
	{
		colorScale = scale;
		colorOffset = offset;
	}

	private bool LatchLayerTextures()
	{
		if (isExternalSurface)
		{
			return true;
		}

		for (int i = 0; i < texturesPerStage; ++i)
		{
			if (textures[i] != layerTextures[i].appTexture || layerTextures[i].appTexturePtr == IntPtr.Zero)
			{
				if (textures[i] != null)
				{
#if UNITY_EDITOR
					var assetPath = UnityEditor.AssetDatabase.GetAssetPath(textures[i]);
					var importer = (UnityEditor.TextureImporter)UnityEditor.TextureImporter.GetAtPath(assetPath);
					if (importer && importer.textureType != UnityEditor.TextureImporterType.Default)
					{
						Debug.LogError("Need Default Texture Type for overlay");
						return false;
					}
#endif
					var rt = textures[i] as RenderTexture;
					if (rt && !rt.IsCreated())
						rt.Create();

					layerTextures[i].appTexturePtr = (texturePtrs[i] != IntPtr.Zero) ? texturePtrs[i] : textures[i].GetNativeTexturePtr();

					if (layerTextures[i].appTexturePtr != IntPtr.Zero)
						layerTextures[i].appTexture = textures[i];
				}
			}

			if (currentOverlayShape == OverlayShape.Cubemap)
			{
				if (textures[i] as Cubemap == null)
				{
					Debug.LogError("Need Cubemap texture for cube map overlay");
					return false;
				}
			}
		}

#if !UNITY_ANDROID || UNITY_EDITOR
		if (currentOverlayShape == OverlayShape.OffcenterCubemap)
		{
			Debug.LogWarning("Overlay shape " + currentOverlayShape + " is not supported on current platform");
			return false;
		}
#endif

		if (layerTextures[0].appTexture == null || layerTextures[0].appTexturePtr == IntPtr.Zero)
			return false;

		return true;
	}

	private OVRPlugin.LayerDesc GetCurrentLayerDesc()
	{
		OVRPlugin.Sizei textureSize = new OVRPlugin.Sizei() { w = 0, h = 0 };

		if (isExternalSurface)
		{
			textureSize.w = externalSurfaceWidth;
			textureSize.h = externalSurfaceHeight;
		}
		else
		{
			if (textures[0] == null)
			{
				Debug.LogWarning("textures[0] hasn't been set");
			}
			textureSize.w = textures[0] ? textures[0].width : 0;
			textureSize.h = textures[0] ? textures[0].height : 0;
		}

		OVRPlugin.LayerDesc newDesc = new OVRPlugin.LayerDesc() {
			Format = layerTextureFormat,
			LayerFlags = isExternalSurface ? 0 : (int)OVRPlugin.LayerFlags.TextureOriginAtBottomLeft,
			Layout = layout,
			MipLevels = 1,
			SampleCount = 1,
			Shape = (OVRPlugin.OverlayShape)currentOverlayShape,
			TextureSize = textureSize
		};

		var tex2D = textures[0] as Texture2D;
		if (tex2D != null)
		{
			if (tex2D.format == TextureFormat.RGBAHalf || tex2D.format == TextureFormat.RGBAFloat)
				newDesc.Format = OVRPlugin.EyeTextureFormat.R16G16B16A16_FP;

			newDesc.MipLevels = tex2D.mipmapCount;
		}

		var texCube = textures[0] as Cubemap;
		if (texCube != null)
		{
			if (texCube.format == TextureFormat.RGBAHalf || texCube.format == TextureFormat.RGBAFloat)
				newDesc.Format = OVRPlugin.EyeTextureFormat.R16G16B16A16_FP;

			newDesc.MipLevels = texCube.mipmapCount;
		}

		var rt = textures[0] as RenderTexture;
		if (rt != null)
		{
			newDesc.SampleCount = rt.antiAliasing;

			if (rt.format == RenderTextureFormat.ARGBHalf || rt.format == RenderTextureFormat.ARGBFloat || rt.format == RenderTextureFormat.RGB111110Float)
				newDesc.Format = OVRPlugin.EyeTextureFormat.R16G16B16A16_FP;
		}

		if (isProtectedContent)
		{
			newDesc.LayerFlags |= (int)OVRPlugin.LayerFlags.ProtectedContent;
		}

		if (isExternalSurface)
		{
			newDesc.LayerFlags |= (int)OVRPlugin.LayerFlags.AndroidSurfaceSwapChain;
		}

		return newDesc;
	}

	private Rect GetBlitRect(int eyeId)
	{
		if (texturesPerStage == 2)
		{
			return eyeId == 0 ? srcRectLeft : srcRectRight;
		}
		else
		{
			// Get intersection of both rects if we use the same texture for both eyes
			float minX = Mathf.Min(srcRectLeft.x, srcRectRight.x);
			float minY = Mathf.Min(srcRectLeft.y, srcRectRight.y);
			float maxX = Mathf.Max(srcRectLeft.x + srcRectLeft.width, srcRectRight.x + srcRectRight.width);
			float maxY = Mathf.Max(srcRectLeft.y + srcRectLeft.height, srcRectRight.y + srcRectRight.height);
			return new Rect(minX, minY, maxX - minX, maxY - minY);
		}
	}

	// A blit method that only draws into the specified rect by setting the viewport.
	private void BlitSubImage(Texture src, RenderTexture dst, Material mat, Rect rect)
	{
		var p = RenderTexture.active;
		RenderTexture.active = dst;

		// our rects are inverted
		rect.y = 1 - rect.y - rect.height;
		var viewport = new Rect(dst.width * rect.x, dst.height * rect.y, dst.width * rect.width, dst.height * rect.height);

		// do our blit using GL ops
		GL.PushMatrix();
		GL.Viewport(viewport);
		GL.LoadPixelMatrix(viewport.x, viewport.x + viewport.width, viewport.y, viewport.y + viewport.height);
		tex2DMaterial.mainTexture = src;
		tex2DMaterial.SetPass(0);

		GL.Begin(GL.TRIANGLES);
		GL.TexCoord(new Vector2(rect.x, rect.y));
		GL.Vertex3(viewport.x, viewport.y, 0);
		GL.TexCoord(new Vector2(rect.x, rect.y + rect.height * 2));
		GL.Vertex3(viewport.x, viewport.y + viewport.height * 2, 0);
		GL.TexCoord(new Vector2(rect.x + rect.width * 2, rect.y));
		GL.Vertex3(viewport.x + viewport.width * 2, viewport.y, 0);
		GL.End();
		GL.Flush();

		GL.PopMatrix();
		RenderTexture.active = p;
	}

	private bool PopulateLayer(int mipLevels, bool isHdr, OVRPlugin.Sizei size, int sampleCount, int stage)
	{
		if (isExternalSurface)
		{
			return true;
		}

		bool ret = false;

		RenderTextureFormat rtFormat = (isHdr) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32;

		for (int eyeId = 0; eyeId < texturesPerStage; ++eyeId)
		{
			Texture et = layerTextures[eyeId].swapChain[stage];
			if (et == null)
				continue;

			for (int mip = 0; mip < mipLevels; ++mip)
			{
				bool dataIsLinear = isHdr || (QualitySettings.activeColorSpace == ColorSpace.Linear);

				var rt = textures[eyeId] as RenderTexture;
#if UNITY_ANDROID && !UNITY_EDITOR
				dataIsLinear = true; //HACK: Graphics.CopyTexture causes linear->srgb conversion on target write with D3D but not GLES.
#endif
				// PC requries premultiplied Alpha
				bool requiresPremultipliedAlpha = !Application.isMobilePlatform;

				bool linearToSRGB = !isHdr && dataIsLinear;
				// if the texture needs to be premultiplied, premultiply it unless its already premultiplied
				bool premultiplyAlpha = requiresPremultipliedAlpha && !isAlphaPremultiplied;

				bool bypassBlit = !linearToSRGB && !premultiplyAlpha && rt != null && rt.format == rtFormat;

				RenderTexture tempRTDst = null;

				if (!bypassBlit)
				{
					int width = size.w >> mip;
					if (width < 1) width = 1;
					int height = size.h >> mip;
					if (height < 1) height = 1;
					RenderTextureDescriptor descriptor = new RenderTextureDescriptor(width, height, rtFormat, 0);
					descriptor.msaaSamples = sampleCount;
					descriptor.useMipMap = true;
					descriptor.autoGenerateMips = false;
					descriptor.sRGB = false;

					tempRTDst = RenderTexture.GetTemporary(descriptor);

					if (!tempRTDst.IsCreated())
					{
						tempRTDst.Create();
					}

					tempRTDst.DiscardContents();

					Material blitMat = null;
					if (currentOverlayShape != OverlayShape.Cubemap && currentOverlayShape != OverlayShape.OffcenterCubemap)
					{
						blitMat = tex2DMaterial;
					}
					else
					{
						blitMat = cubeMaterial;
					}

					blitMat.SetInt("_linearToSrgb", linearToSRGB ? 1 : 0);
					blitMat.SetInt("_premultiply", premultiplyAlpha ? 1 : 0);
				}

				if (currentOverlayShape != OverlayShape.Cubemap && currentOverlayShape != OverlayShape.OffcenterCubemap)
				{
					if (bypassBlit)
					{
						Graphics.CopyTexture(textures[eyeId], 0, mip, et, 0, mip);
					}
					else
					{
						if (overrideTextureRectMatrix)
						{
							BlitSubImage(textures[eyeId], tempRTDst, tex2DMaterial, GetBlitRect(eyeId));
						}
						else
						{
							Graphics.Blit(textures[eyeId], tempRTDst, tex2DMaterial);
						}
						//Resolve, decompress, swizzle, etc not handled by simple CopyTexture.
						Graphics.CopyTexture(tempRTDst, 0, 0, et, 0, mip);
					}
				}
				else // Cubemap
				{
					for (int face = 0; face < 6; ++face)
					{
						cubeMaterial.SetInt("_face", face);
						if (bypassBlit)
						{
							Graphics.CopyTexture(textures[eyeId], face, mip, et, face, mip);
						}
						else
						{
							//Resolve, decompress, swizzle, etc not handled by simple CopyTexture.
							Graphics.Blit(textures[eyeId], tempRTDst, cubeMaterial);
							Graphics.CopyTexture(tempRTDst, 0, 0, et, face, mip);
						}
					}
				}
				if (tempRTDst != null)
				{
					RenderTexture.ReleaseTemporary(tempRTDst);
				}

				ret = true;
			}
		}

		return ret;
	}

	private bool SubmitLayer(bool overlay, bool headLocked, bool noDepthBufferTesting, OVRPose pose, Vector3 scale, int frameIndex)
	{
		int rightEyeIndex = (texturesPerStage >= 2) ? 1 : 0;
		if (overrideTextureRectMatrix)
		{
			UpdateTextureRectMatrix();
		}
		bool isOverlayVisible = OVRPlugin.EnqueueSubmitLayer(overlay, headLocked, noDepthBufferTesting,
			isExternalSurface ? System.IntPtr.Zero : layerTextures[0].appTexturePtr,
			isExternalSurface ? System.IntPtr.Zero : layerTextures[rightEyeIndex].appTexturePtr,
			layerId, frameIndex, pose.flipZ().ToPosef_Legacy(), scale.ToVector3f(), layerIndex, (OVRPlugin.OverlayShape)currentOverlayShape,
			overrideTextureRectMatrix, textureRectMatrix, overridePerLayerColorScaleAndOffset, colorScale, colorOffset, useExpensiveSuperSample,
			hidden);

		prevOverlayShape = currentOverlayShape;

		return isOverlayVisible;
	}

	private void SetupEditorPreview()
	{
		#if UNITY_EDITOR
			if (previewInEditor && previewObject == null)
			{
				previewObject = new GameObject();
				previewObject.hideFlags = HideFlags.HideAndDontSave;
				previewObject.transform.SetParent(this.transform, false);
				OVROverlayMeshGenerator generator = previewObject.AddComponent<OVROverlayMeshGenerator>();
				generator.SetOverlay(this);

			}
			else if (!previewInEditor && previewObject != null)
			{
				UnityEngine.Object.DestroyImmediate(previewObject);
				previewObject = null;
			}
		#endif
	}

#region Unity Messages

	void Awake()
	{
		Debug.Log("Overlay Awake");

		if (Application.isPlaying)
		{
			if (tex2DMaterial == null)
				tex2DMaterial = new Material(Shader.Find("Oculus/Texture2D Blit"));

			if (cubeMaterial == null)
				cubeMaterial = new Material(Shader.Find("Oculus/Cubemap Blit"));
		}

		rend = GetComponent<Renderer>();

		if (textures.Length == 0)
			textures = new Texture[] { null };

		// Backward compatibility
		if (rend != null && textures[0] == null)
			textures[0] = rend.material.mainTexture;

		SetupEditorPreview();
	}

	static public string OpenVROverlayKey { get { return "unity:" + Application.companyName + "." + Application.productName; } }
	private ulong OpenVROverlayHandle = OVR.OpenVR.OpenVR.k_ulOverlayHandleInvalid;

	void OnEnable()
	{
		if (OVRManager.OVRManagerinitialized)
			InitOVROverlay();

	#if UNITY_EDITOR
		if (previewObject != null) {
			previewObject.SetActive(true);
		}
	#endif
	}

	void InitOVROverlay()
	{
		if (!OVRManager.isHmdPresent)
		{
			enabled = false;
			return;
		}

		constructedOverlayXRDevice = OVRManager.XRDevice.Unknown;
		if (OVRManager.loadedXRDevice == OVRManager.XRDevice.OpenVR)
		{
			OVR.OpenVR.CVROverlay overlay = OVR.OpenVR.OpenVR.Overlay;
			if (overlay != null)
			{
				OVR.OpenVR.EVROverlayError error = overlay.CreateOverlay(OpenVROverlayKey + transform.name, gameObject.name, ref OpenVROverlayHandle);
				if (error != OVR.OpenVR.EVROverlayError.None)
				{
					enabled = false;
					return;
				}
			}
			else
			{
				enabled = false;
				return;
			}
		}

		constructedOverlayXRDevice = OVRManager.loadedXRDevice;
		xrDeviceConstructed = true;
	}

	void OnDisable()
	{
	
	#if UNITY_EDITOR
		if (previewObject != null) {
			previewObject.SetActive(false);
		}
	#endif

		if ((gameObject.hideFlags & HideFlags.DontSaveInBuild) != 0)
			return;

		if (!OVRManager.OVRManagerinitialized)
			return;

		if (OVRManager.loadedXRDevice != constructedOverlayXRDevice)
			return;

		if (OVRManager.loadedXRDevice == OVRManager.XRDevice.Oculus)
		{
			DestroyLayerTextures();
			DestroyLayer();
		}
		else if (OVRManager.loadedXRDevice == OVRManager.XRDevice.OpenVR)
		{
			if (OpenVROverlayHandle != OVR.OpenVR.OpenVR.k_ulOverlayHandleInvalid)
			{
				OVR.OpenVR.CVROverlay overlay = OVR.OpenVR.OpenVR.Overlay;
				if (overlay != null)
				{
					overlay.DestroyOverlay(OpenVROverlayHandle);
				}
				OpenVROverlayHandle = OVR.OpenVR.OpenVR.k_ulOverlayHandleInvalid;
			}
		}
		constructedOverlayXRDevice = OVRManager.XRDevice.Unknown;
		xrDeviceConstructed = false;
	}

	void OnDestroy()
	{
		DestroyLayerTextures();
		DestroyLayer();

	#if UNITY_EDITOR
		if (previewObject != null) {
			GameObject.DestroyImmediate(previewObject);
		}
	#endif
	}

	bool ComputeSubmit(ref OVRPose pose, ref Vector3 scale, ref bool overlay, ref bool headLocked)
	{
		Camera headCamera = Camera.main;

		overlay = (currentOverlayType == OverlayType.Overlay);
		headLocked = false;
		for (var t = transform; t != null && !headLocked; t = t.parent)
			headLocked |= (t == headCamera.transform);

		pose = (headLocked) ? transform.ToHeadSpacePose(headCamera) : transform.ToTrackingSpacePose(headCamera);
		scale = transform.lossyScale;
		for (int i = 0; i < 3; ++i)
			scale[i] /= headCamera.transform.lossyScale[i];

		if (currentOverlayShape == OverlayShape.Cubemap)
		{
#if UNITY_ANDROID && !UNITY_EDITOR
			//HACK: VRAPI cubemaps assume are yawed 180 degrees relative to LibOVR.
			pose.orientation = pose.orientation * Quaternion.AngleAxis(180, Vector3.up);
#endif
			pose.position = headCamera.transform.position;
		}

		// Pack the offsetCenter directly into pose.position for offcenterCubemap
		if (currentOverlayShape == OverlayShape.OffcenterCubemap)
		{
			pose.position = transform.position;
			if (pose.position.magnitude > 1.0f)
			{
				Debug.LogWarning("Your cube map center offset's magnitude is greater than 1, which will cause some cube map pixel always invisible .");
				return false;
			}
		}

		// Cylinder overlay sanity checking
		if (currentOverlayShape == OverlayShape.Cylinder)
		{
			float arcAngle = scale.x / scale.z / (float)Math.PI * 180.0f;
			if (arcAngle > 180.0f)
			{
				Debug.LogWarning("Cylinder overlay's arc angle has to be below 180 degree, current arc angle is " + arcAngle + " degree." );
				return false;
			}
		}

		return true;
	}

	void OpenVROverlayUpdate(Vector3 scale, OVRPose pose)
	{
		OVR.OpenVR.CVROverlay overlayRef = OVR.OpenVR.OpenVR.Overlay;
		if (overlayRef == null)
			return;

		Texture overlayTex = textures[0];

		if (overlayTex != null)
		{
			OVR.OpenVR.EVROverlayError error = overlayRef.ShowOverlay(OpenVROverlayHandle);
			if (error == OVR.OpenVR.EVROverlayError.InvalidHandle || error == OVR.OpenVR.EVROverlayError.UnknownOverlay)
			{
				if (overlayRef.FindOverlay(OpenVROverlayKey + transform.name, ref OpenVROverlayHandle) != OVR.OpenVR.EVROverlayError.None)
					return;
			}

			OVR.OpenVR.Texture_t tex = new OVR.OpenVR.Texture_t();
			tex.handle = overlayTex.GetNativeTexturePtr();
			tex.eType = SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL") ? OVR.OpenVR.ETextureType.OpenGL : OVR.OpenVR.ETextureType.DirectX;
			tex.eColorSpace = OVR.OpenVR.EColorSpace.Auto;
			overlayRef.SetOverlayTexture(OpenVROverlayHandle, ref tex);

			OVR.OpenVR.VRTextureBounds_t textureBounds = new OVR.OpenVR.VRTextureBounds_t();
			textureBounds.uMin = (0 + OpenVRUVOffsetAndScale.x) * OpenVRUVOffsetAndScale.z;
			textureBounds.vMin = (1 + OpenVRUVOffsetAndScale.y) * OpenVRUVOffsetAndScale.w;
			textureBounds.uMax = (1 + OpenVRUVOffsetAndScale.x) * OpenVRUVOffsetAndScale.z;
			textureBounds.vMax = (0 + OpenVRUVOffsetAndScale.y) * OpenVRUVOffsetAndScale.w;

			overlayRef.SetOverlayTextureBounds(OpenVROverlayHandle, ref textureBounds);

			OVR.OpenVR.HmdVector2_t vecMouseScale = new OVR.OpenVR.HmdVector2_t();
			vecMouseScale.v0 = OpenVRMouseScale.x;
			vecMouseScale.v1 = OpenVRMouseScale.y;
			overlayRef.SetOverlayMouseScale(OpenVROverlayHandle, ref vecMouseScale);

			overlayRef.SetOverlayWidthInMeters(OpenVROverlayHandle, scale.x);

			Matrix4x4 mat44 = Matrix4x4.TRS(pose.position, pose.orientation, Vector3.one);

			OVR.OpenVR.HmdMatrix34_t pose34 = mat44.ConvertToHMDMatrix34();

			overlayRef.SetOverlayTransformAbsolute(OpenVROverlayHandle, OVR.OpenVR.ETrackingUniverseOrigin.TrackingUniverseStanding, ref pose34);

		}
	}

	private Vector4 OpenVRUVOffsetAndScale = new Vector4(0, 0, 1.0f, 1.0f);
	private Vector2 OpenVRMouseScale = new Vector2(1, 1);
	private OVRManager.XRDevice constructedOverlayXRDevice;
	private bool xrDeviceConstructed = false;

	void LateUpdate()
	{
		if (!OVRManager.OVRManagerinitialized)
			return;
		if (!xrDeviceConstructed)
		{
			InitOVROverlay();
		}

		if (OVRManager.loadedXRDevice != constructedOverlayXRDevice)
		{
			Debug.LogError("Warning-XR Device was switched during runtime with overlays still enabled. When doing so, all overlays constructed with the previous XR device must first be disabled.");
			return;
		}
		// The overlay must be specified every eye frame, because it is positioned relative to the
		// current head location.  If frames are dropped, it will be time warped appropriately,
		// just like the eye buffers.
		if (currentOverlayType == OverlayType.None || ((textures.Length < texturesPerStage || textures[0] == null) && !isExternalSurface))
			return;

		OVRPose pose = OVRPose.identity;
		Vector3 scale = Vector3.one;
		bool overlay = false;
		bool headLocked = false;
		if (!ComputeSubmit(ref pose, ref scale, ref overlay, ref headLocked))
			return;

		if (OVRManager.loadedXRDevice == OVRManager.XRDevice.OpenVR)
		{
			if (currentOverlayShape == OverlayShape.Quad)
				OpenVROverlayUpdate(scale, pose);
			//No more Overlay processing is required if we're on OpenVR
			return;
		}

		OVRPlugin.LayerDesc newDesc = GetCurrentLayerDesc();
		bool isHdr = (newDesc.Format == OVRPlugin.EyeTextureFormat.R16G16B16A16_FP);

		// If the layer and textures are created but sizes differ, force re-creating them
		if (!layerDesc.TextureSize.Equals(newDesc.TextureSize) && layerId > 0)
		{
			DestroyLayerTextures();
			DestroyLayer();
		}

		bool createdLayer = CreateLayer(newDesc.MipLevels, newDesc.SampleCount, newDesc.Format, newDesc.LayerFlags, newDesc.TextureSize, newDesc.Shape);

		if (layerIndex == -1 || layerId <= 0)
			return;

		bool useMipmaps = (newDesc.MipLevels > 1);

		createdLayer |= CreateLayerTextures(useMipmaps, newDesc.TextureSize, isHdr);

		if (!isExternalSurface && (layerTextures[0].appTexture as RenderTexture != null))
			isDynamic = true;

		if (!LatchLayerTextures())
			return;

		// Don't populate the same frame image twice.
		if (frameIndex > prevFrameIndex)
		{
			int stage = frameIndex % stageCount;
			if (!PopulateLayer (newDesc.MipLevels, isHdr, newDesc.TextureSize, newDesc.SampleCount, stage))
				return;
		}

		bool isOverlayVisible = SubmitLayer(overlay, headLocked, noDepthBufferTesting, pose, scale, frameIndex);

		prevFrameIndex = frameIndex;
		if (isDynamic)
			++frameIndex;

		// Backward compatibility: show regular renderer if overlay isn't visible.
		if (rend)
			rend.enabled = !isOverlayVisible;
	}

#endregion
}
